Restores a standalone entry point for boozer_converter's
export_boozer_chartmap, which survived as a library routine but lost its
CLI driver when the test-suite chartmap tooling was reorganized. As an
app (not a test): reads field config from simple.in, builds the internal
Boozer field via init_field exactly as a tracing run does, and writes the
chartmap in the current rho+s schema (A_phi on the s abscissa). Enables a
direct field-level comparison of SIMPLE's VMEC->Boozer transform against
an external booz_xform chartmap.

Usage: export_boozer_chartmap.x <out.nc> [config.in]

…es on VMEC

Replace the diagonal analytic-tokamak metric in orbit_cpp_canonical with a full
(non-diagonal) metric path so the cp/cpp_sym/cpp_var integrators run on real
VMEC flux coordinates and reduce to the analytic tokamak as a special case.

- block_t carries g_ij, g^ij, dg_ij,k, covariant A_i + gradient, |B| + gradient,
  h_i. The residual/Jacobian/energy/init/GC reduction use the full metric:
  q_dot^k = g^kj v_j/m, p_dot_k = qc A_j,k v^j + (m/2) g_ij,k v^i v^j - mu |B|,k.
- COORD_TOK fills the diagonal block inline, !$acc routine seq, class-free, with
  the analytic Jacobian. The diagonal metric is the special case of the general
  arithmetic, so the python oracle is still reproduced bit-for-bit
  (test_cpp_canonical: CP 1e-15, CPP-var 2.8e-8, energy plateau, analytic==FD).
- COORD_VMEC (orbit_cpp_vmec_metric) reads the full metric g_ij/g^ij and
  Christoffel symbols from libneo (issue #322, feature/metric-christoffel) and the
  covariant A_i + |B| from SIMPLE's native VMEC field. Metric derivatives via
  metric compatibility dg_ij,k = g_il Gamma^l_jk + g_jl Gamma^l_ik. Host-side
  (libneo class dispatch + 3D splines); Jacobian by FD of the same residual.
- Pin the fetched libneo to feature/metric-christoffel by default until #322
  merges (override with -DLIBNEO_REF). Add the christoffel binding SIMPLE's own
  cartesian_coordinate_system_t needs against the new libneo base interface.
- test_cpp_vmec runs CP + big-step CPP on test_data/wout.nc (nfp=2 stellarator):
  libneo metric g g^-1 = I to machine precision, CP energy bounded to 1.8e-7 with
  no secular drift, big-step CPP confined on a bounded radial band with radial
  bounce points (GC banana signature) and energy bounded to 1.9e-9. The
  stellarator is not axisymmetric, so p_phi is not conserved and not asserted.

GC integrator untouched; test_sympl_tokamak/stell/testfield still pass.

Correctness: the analytic-tokamak field carried over a wrong d|B|/dtheta
(field_correct_test.py dropped the A_theta,rth chain-rule term). Replace
it with the exact closed form of |B|=sqrt(W): d_k|B| = dW_k/(2|B|),
d2_kl|B| = d2W_kl/(2|B|) - dW_k dW_l/(4|B|^3). FD-verified to ~1e-9 at
several (r,theta). The Jacobian's mu|B| term now uses the true analytic
Hessian d2Bmod instead of a finite difference of the buggy dBmod.

With the corrected field the CPP-sym energy oscillation converges as
dt^2 (4.2e-5, 1.0e-5, 2.2e-6, 4.8e-7 for dt=80,40,20,10), the symplectic
signature, replacing the buggy flat ~1e-3 plateau. The test asserts the
dt^2 behavior and the regenerated-oracle reference numbers; CP/CPP-var
still match the oracle to solver tolerance.

GPU: cpp_canon_step_tok is the device entry. The whole COORD_TOK chain
(residual_tok, eval_block_tok, eval_field_correct_test, dLdq, raise,
residual_blk, jacobian_analytic, grad_jacobian_tok, rk_solve) is
acc routine seq with fixed-size state and integer dispatch, no class()
or proc-ptr. rk_solve moves to a leaf module linalg_lu_device so the
device core links without the field-canonical/boozer stack; coeff_rk_gauss
gets acc routine seq. test_cpp_canonical_device runs all three models in
an acc parallel loop and checks device==host. COORD_VMEC stays host-only
(libneo class dispatch + 3D splines).

Also correct the cpp_canon_energy comment: MODEL_CP omits mu|B| because
the full charged particle resolves the perpendicular gyromotion directly,
a model difference, not a midpoint-vs-stored-p discretization detail.

Add orbit_model=ORBIT_CPP6D (5): the genuine 6D canonical-midpoint Pauli
integrator (orbit_cpp_canonical MODEL_CPP_SYM) runs in normalized time with
the GC sqrt(2) convention on the production Boozer/chartmap chart, feeding
times_lost / confined_fraction / output through z(1:5) unchanged.

- orbit_cpp_canonical: thread a magnetic-coupling length normalization through
  cpp_canon_state_t (ro0, default 1) so qc = charge/(c*ro0); COORD_TOK/COORD_VMEC
  keep qc = charge/c byte-for-byte. Add COORD_CHARTMAP + eval_block_chartmap and
  a carried pabs field.
- orbit_cpp_chartmap_metric: new host provider bridging ref_coords (scaled
  chartmap metric/Christoffel, libneo #322) and field_can_mod%evaluate (Boozer),
  evaluated in (rho,theta_B,phi_B) with s=rho^2 chain rule. chartmap_metric_active
  gates the path.
- simple.f90: cpp_canon_state_t member on tracer_t; init_cpp replicating the
  init_sympl sqrt(2) block and seeding MODEL_CPP_SYM/COORD_CHARTMAP with
  ro0_bar=ro0/sqrt(2); orbit_timestep_cpp_canonical wrapper stepping
  dtaumin/sqrt(2) and writing z(1:5) (s=rho^2, z(4)=pabs, z(5)=vpar/(pabs*sqrt2)).
- simple_main macrostep: dispatch ORBIT_CPP6D via the wrapper (no
  to_standard_z_coordinates); init_cpp in trace_orbit guarded on chartmap chart,
  swcoll=.false., no wall. GC and ORBIT_PAULI paths unchanged.
- classification: error stop ORBIT_CPP6D (classifier stencil follow-up).
- orbit_full / params: ORBIT_CPP6D=5 constant and namelist comment.
- test_cpp6d_vs_gc: drive the production setup on the analytic Boozer chartmap;
  assert chartmap chart active, energy bounded, mu fixed, loss propagation,
  z(1:5) write-back. Extend test_orbit_model_dispatch with ORBIT_CPP6D.
- DOC/coordinates-and-fields.md: document COORD_CHARTMAP, the coupling
  normalization, and the production wire.

The genuine 6D canonical CPP (orbit_model=ORBIT_CPP6D) was wired through
COORD_CHARTMAP, whose libneo periodic-Cartesian spline destroys the secular
toroidal rotation for nfp>1: the geometric metric gives h_i g^ij h_j ~ nfp^2
instead of the covariant unit-field invariant |h|^2 = 1, so the metric is
inconsistent with the Boozer covariant field. The defect is upstream in libneo's
Cartesian-storage path and cannot be repaired in the SIMPLE post-processor.

Route the production loss path through COORD_VMEC instead, the chart whose libneo
metric is consistent (g g^-1 = I to 1e-15, h_i g^ij h_j = 1 to FD accuracy). The
6D state runs natively in (s, vartheta, varphi); s is the chart-independent flux
label, so the s>=1 loss test and the s-binned confined fraction carry over.

- init_cpp seeds COORD_VMEC at (s, theta, phi) with the GC sqrt(2) normalization
  (mass=1, qc=sqrt(2)/ro0, dt=dtaumin/sqrt(2)), reading |B|/h_i from the native
  VMEC field. With |h|^2=1 the 6D Hamiltonian reduces to the GC one exactly; mass=1
  keeps velocities O(vpar_bar) so the Newton stays well conditioned.
- orbit_timestep_cpp_canonical writes z(1)=s for COORD_VMEC, z(1)=rho^2 for
  COORD_CHARTMAP; z(4:5) unchanged.
- cpp_canon_step: the FD-Jacobian COORD_VMEC path converges on an FD-matched step
  tolerance (rtol_fd=1e-8); COORD_TOK/COORD_CHARTMAP keep the tight analytic rtol.
  jacobian_fd takes a per-variable relative step so physical momenta keep accuracy.
- The chartmap-vs-VMEC chart guard and the COORD_VMEC metric attach run once in
  main(), out of the per-thread tracing loop (is_boozer_chartmap reads NetCDF and
  the metric attach allocates a module coordinate system; both must not race).
- orbit_cpp_chartmap_metric: rename drho_ds -> ds_drho (it holds ds/drho=2 rho).

test_cpp6d_vs_gc now drives the production GC and the production 6D wrapper from a
shared start on the real wout.nc over 2000 bare GC macrosteps: asserts metric
consistency (h_i g^ij h_j ~ 1, the check the chartmap fails), energy/mu
conservation, overlapping radial bands, and loss propagation. An end-to-end
32-particle run gives CPP6D confined fraction 0.91 vs GC 0.97 at 1e-3 s.

DOC/coordinates-and-fields.md section 6.6 updated to the current reality.

Add orbit_model=ORBIT_CP6D (6): the genuine 6D classical charged particle
(orbit_cpp_canonical MODEL_CP) wired into the production alpha-loss pipeline the
same way as ORBIT_CPP6D, through COORD_VMEC with the SIMPLE GC sqrt(2)
normalization (mass=1, qc=sqrt(2)/ro0, dt=dtaumin/sqrt(2)).

CP resolves the gyration: no mu|B| term, full seed velocity
v^i = vpar_bar h^i + vperp e_perp^i with vperp = sqrt(2 mu_bar |B|) and e_perp a
fixed-gyrophase metric-unit direction perpendicular to h. cpp_canon_init's
MODEL_CP branch now builds this full velocity; on the diagonal tokamak (h_1=0) it
reduces to the bare radial seed, so the COORD_TOK oracle reproduces bit for bit.

init_cp in simple.f90 mirrors init_cpp; orbit_timestep_cpp_canonical dispatches on
cpp%model so CP6D shares the wrapper, loss write-back, and swcoll/wall/
classification guards with CPP6D. GC, CPP6D, and COORD_TOK paths are unchanged.

Because the gyration is resolved, CP6D needs a gyro-resolving step. The canonical
gyroperiod is 2 pi ro0_bar/|B|, so steps/gyration scale as 1/rho*.
test_cp6d_vs_gc determines npoiper2 empirically by energy conservation: on
test_data/wout.nc (rho*=4.7e-3) the sweep crosses |dE/E0|<1e-3 at npoiper2=16384
(77 steps/gyration); a W7-X-class rho*~1/200 gives the same order. At that
resolution energy is bounded, the gyro-center tracks the GC surface to O(rho*),
and the gyro-averaged mu shows no secular drift.

Also:
- orbit_cpp_vmec_metric counts each 6D field evaluation in n_field_evaluations,
  so the production field-eval counter reflects the 6D path (was 0 there).
- Regenerate version.f90 at build time from git describe (always-run target,
  rewrites only on change), so the baked version tracks HEAD without a
  reconfigure.
- Correct DOC/coordinates-and-fields.md: the COORD_VMEC h_i g^ij h_j=1.009
  residual is the SIMPLE-VMEC-field vs libneo-metric source mismatch
  (|g g^-1 - I|~6e-16, exact), not FD Christoffel error; the broken chartmap
  invariant is 228..472 (O(10^2)), not nfp^2.

## Summary
- document chartmap `sbeg`, radial-grid, handedness, sign, and runtime
scaling conventions
- clarify GVEC and booz_xform converter comments without changing
exporter numerics
- remove small lint blockers surfaced by `fo`

## Verification
- `python -m py_compile tools/gvec_to_boozer_chartmap.py
tools/booz_xform_to_boozer_chartmap.py` passed.
- `$HOME/code/prompts/scripts/check-writing-slop.py --threshold soft
README.md docs/boozer-chartmap-schema.rst` passed: `PASS: no
writing-slop candidates at threshold soft`.
- `/home/ert/.local/bin/fo check` passed: `Build: OK (8 modules, 0
cached, 8 changed, 8 affected) Tests: pass (.1s)`.
- `/home/ert/.local/bin/fo lint` passed: `no issues found`.
- Full `/home/ert/.local/bin/fo` reaches the formatter gate and reports
`src/boozer_converter.F90`, `src/field.F90`,
`src/field/field_newton.F90`, `src/get_canonical_coordinates.F90`, and
`src/util.F90`. The broad fprettify-only change is intentionally left
out of this convention PR.

Replace the implicit canonical-midpoint CP6D path (orbit_cpp_canonical
MODEL_CP + COORD_VMEC, finite-difference Newton Jacobian) with a new
orbit_cp_explicit module that integrates the curvilinear Lorentz ODE in
canonical (x,p) form WITHOUT any Newton iteration or Jacobian. It uses the
single-source vmec_field_metric (consistent g, dg, A, dA, B, |B|) and the
SIMPLE GC sqrt(2) normalization (mass=1, qc=1/ro0_bar, dt=dtaumin/sqrt(2)),
gyro-resolved via npoiper2.

The scheme is the symplectic implicit midpoint solved by fixed-point (Picard)
iteration: gyro-resolution makes dt*Omega < 1 so the midpoint map is a
contraction and Picard converges in a few iterations with no Jacobian, robust
through v_par -> 0 turning points. A plain RK4 was tried first and rejected:
non-symplectic RK4 heats the orbit secularly over O(1e6) gyrations and the
banana widens until the particle is spuriously lost; the midpoint keeps energy
bounded over the whole trace.

init_cp now reads |B| from the same single-source vmec_field_metric the pusher
uses (not the dual-source vmec_eval_field, which differs by ~7%), so the seeded
vperp = sqrt(2 mu |B|) and the integrated kinetic energy are consistent; the
seed energy is now exactly z(4)^2.

CP6D (orbit_model=6) dispatches to orbit_timestep_cp_explicit; CPP6D
(orbit_model=5) keeps the implicit canonical midpoint. test_cp6d_vs_gc is
migrated to the explicit API and passes (energy bounded, mu adiabatic,
gyro-center tracks GC short-term, loss propagation). No GC regression
(test_sympl* pass).

Known limitation: on the QA test_data/wout.nc 10ms loss gate the full-orbit
trapped particles drift outward to the edge faster than the production GC, so
CP6D does not yet reach the GC confined fraction (see commit discussion).

…ierr=2)

A full-orbit particle whose gyro-position maps outside the s<1 plasma is a
PHYSICAL edge loss, but cart_to_boozer clamps s to the boundary and the inversion
stalls, so it was reported as a numerical failure (cpp_lu_fail). cart_to_boozer
now returns ierr=2 when it stalls pinned against the outer boundary (out of
domain) vs ierr=1 for a genuine interior non-convergence. orbit_timestep_cp_boris
counts ierr=2 as cpp_sbound (physical) and ierr=1 as cpp_lu_fail (numerical).

Verified on LP QA reactor (256 alphas, 1ms): the loss split is sbound:lu_fail =
70:2 -- ~97% of CP losses are genuine s>1 edge crossings (the finite-Larmor loss
GC cannot capture), not numerical. Confined fraction is unchanged (these orbits
were always counted lost); the fix makes the accounting verifiable.

Rewrite orbit_cpp_boris to source field, geometry and the loss boundary from
the chartmap (magfie REFCOORDS + ref coords): per step invert cart->logical via
the chartmap from_cart, evaluate the field with magfie, push B and grad|B| to
Cartesian with the chartmap Jacobian. No boozer harmonic metric on this path.

Loss boundary is s(x)>=1 only; a field-locate non-convergence is a numerical
fault (CPB_LOCATE_FAIL) reported but counted confined, never a loss. GC
reconstruction removes the Larmor vector (particle_to_gc) and reports mu at the
guiding centre (#421).

…nas)

metric_tensor returns sqrtg = sqrt(|det|) (unsigned). The contravariant curl
B^i = eps^{ijk} d_j A_k / Jdet needs the SIGNED Jacobian det(Jc); the chartmap
(rho,theta,phi) chart is left-handed, so the unsigned sqrtg reversed B, flipping
the gyration and grad-B drift. Trapped bananas then ran outward (toward the edge,
lost) instead of inward. With det(Jc): single-orbit trapped CP bananas match the
GC (e.g. s 0.50->0.20 inward), and reactor W7-X CP confined 0.78 -> 0.862 (GC
0.905, ASCOT FO 0.898).

Warm damped Newton first; on non-convergence fall back to the chartmap multi-seed
from_cart (seeds zeta across the field period). Rescues some field-period-seam
stale-guess failures. Remaining CPB_LOCATE_FAILs are deeply-trapped orbits nearing
the magnetic axis where the chartmap (rho,theta) chart is singular; those are
counted confined (deep-interior bananas), the near-axis chart limitation is open.

Unify the times_lost.dat convention across integrators. The CP/CPP chartmap paths
produce ierr_orbit==3 field-locate faults (near-axis), which GC never has; the fault
branch wrote times_lost=-1 for these confined survivors while every clean-confined
particle (GC included) gets trace_time. -1 then collided with the never-traced
(skipped passing) marker value, so a script keying 'confined' on times_lost==trace_time
miscounted CP. A fault is not a loss and the particle is confined, so record trace_time
like GC; the fault is tracked by the diag counters. Verified: GC and CP now write an
identical convention (309 skipped t=-1, rest confined t=trace_time, lost 0<t<trace_time).

## What

Reindent 31 files with `fprettify` to the formatting the 6D-port branch
(#408) already uses, so that PR's diff carries real changes only. This
is
formatting churn lifted out ahead of it: ~7600 of #408's ~18900 changed
lines are reindentation.

`fprettify` 0.3.7 with the repo `.fprettify` config (4-space indent, 88
cols) produces these files from `main`. `get_canonical_coordinates.F90`
is
the branch's whole-file reformat, taken verbatim (zero real change).

## No semantic change

```
$ git diff -w --ignore-blank-lines origin/main
(empty)
```

No token changes anywhere: only indentation and blank-line
normalization.
Build passes (`make CONFIG=Fast`).

## After merge

Rebasing #408 on top drops the reformatted files from its diff, since
the
formatting matches. The seven files `fprettify` does not reproduce
(`orbit_symplectic`, `classification`, `simple`, `params`,
`field_can_test`,
`simple_main`, plus the field-can hand-formatting) stay in #408 with
their
real changes.

## Risk tier

- [x] T3: physics, output behavior, coordinate convention

## Correctness contract

### Intended behavior change

Adds a new orbit model: `orbit_model = 7` (`ORBIT_FULL_ORBIT`) selects a
gyro-resolved full-orbit (FO) Boris pusher, the ASCOT-style counterpart
to the
guiding-center (GC) model. A charged particle advances by explicit Boris
drift-rotate-drift in Cartesian (x, v); field and geometry come from the
production Boozer field through the chartmap (B = curl A, tangent to the
flux
surface), with the magnetic axis healed by a pseudo-Cartesian (X,Y,phi)
chart.
Output `z(1:5)` is the guiding-centre reduction each step, so
`times_lost` and
`confined_fraction` are written exactly as for GC.

### Behavior that must not change

`orbit_model = 0` (guiding center, the default) is untouched: the
symplectic GC
path, its init, and its macrostep are unchanged. No existing test output
moves.

### Coordinate / unit conventions

Cartesian (x, v) in the scaled chartmap frame; logical chart u=(rho,
theta_B,
phi_B) with rho = sqrt(s). CGS-style normalized velocity with the GC
sqrt(2)
convention, matching the GC seed so both integrators start from the
identical
particle. `orbit_coord = 1` (Boozer) is required and enforced.

### Numerical invariants

Energy is conserved to machine precision (the Boris rotation is exact
for
constant B over a step; no electric field here). The only confinement
loss is
the guiding-centre crossing s >= 1; a field-inversion non-convergence is
a
numerical fault (`fo_fault`), reported but never counted as a loss.

## Tests added

- unit:
- integration: `test_fo_boris` (energy bound < 1e-3, near-axis crossing,
no spurious loss; passing/trapped/near-axis on the reactor-scale Boozer
field)
- system:
- golden record:

## Golden-record impact

- [x] unchanged

GC is the default and is untouched; FO is opt-in via `orbit_model = 7`.

## Failure modes considered

- Field-inversion non-convergence near a field-period seam: classified
as a
numerical fault (`fo_fault`), never a loss, so a mid-radius particle is
not
  spuriously lost.
- Near-axis singularity of the polar chart: healed by the
pseudo-Cartesian
(X,Y,phi) chart; the near-axis test orbit crosses s in [0.04, 0.07] with
  energy bounded.
- Unsupported combinations (wall loss, collisions, orbit classification,
or
orbit_coord /= 1) stop at config validation with a clear message instead
of
  running silently wrong.

## Manual validation

Reactor-scale W7-X benchmark (separate run): FO confined fraction agrees
with
ASCOT5 full orbit (0.894 vs 0.898 at 1 ms, 1000 alphas), and with GC
within
marker statistics.

## Verification

Before: there is no full-orbit model on `main`; `orbit_model` and the FO
modules
do not exist.

```
$ git grep -l 'ORBIT_FULL_ORBIT\|orbit_fo_boris' origin/main -- src test
(no matches)
```

After: `test_fo_boris` passes and the fast suite is green.

```
$ make test TEST=fo_boris
1/1 Test #6: test_fo_boris ....................   Passed    6.01 sec

  passing   s band [0.5000,0.7700]  max|dE/E0|=2.22E-14  ierr_lost=0
  trapped   s band [0.4999,0.5894]  max|dE/E0|=1.11E-14  ierr_lost=0  drift=8.85E-03
  near-axis s band [0.0400,0.0708]  max|dE/E0|=8.88E-15  ierr_lost=0
  ALL FO-BORIS TESTS PASSED

$ make test-fast
100% tests passed, 0 tests failed out of 53
```

## Relationship to #408

This is the working full-orbit Boris slice, extracted clean off `main`.
The
experimental models on #408 (CPP Pauli, the adaptive RK45 ORBIT_CP6D_RK,
the 6D
canonical CP/CPP, device/mock variants) stay on that branch; #408
rebases on top
once this merges.